home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / DEMON / RISCOS2 / TCP_131S.ARC / c / NetTime < prev    next >
Text File  |  1994-03-03  |  7KB  |  267 lines
  1. /*************************************************************************** 
  2.      Purpose        :    Routines for setting KA9Q's time from the remote host.     
  3.                  :    Uses the protocol described in RFC 868.                     
  4.  *************************************************************************** 
  5.                  :    Copyright Giles Todd 1992.  All rights reserved.         
  6.                  :    The right of Giles Todd to be identified as the author     
  7.                  :    of this work has been asserted by him in accordance         
  8.                  :    with the Copyrights, Designs and Patents Act, 1988.         
  9.                  :    No restrictions on the use of this module with KA9Q.     
  10.  ***************************************************************************/
  11.  
  12. #include    <stdio.h>
  13. #include    <stdlib.h>
  14. #include    <time.h>
  15. #include    "Arc.h"
  16. #include    "domain.h"
  17. #include    "global.h"
  18. #include    "mbuf.h"
  19. #include    "misc.h"
  20. #include    "cmdparse.h"
  21. #include    "socket.h"
  22. #include    "timer.h"
  23. #include    "netuser.h"
  24. #include    "udp.h"
  25.  
  26. int done_set_time = 0;    /* have we set the time since this open?    */
  27.  
  28. #define TIME_PORT 37
  29.  
  30. extern int16 lport;                     /* local port placeholder */
  31. extern int32 wimp_ver;
  32.  
  33. /*************************************************************************** 
  34.      Static function declarations.                                             
  35.  ***************************************************************************/
  36.  
  37. static int do_server (int argc, char **argv);
  38. static int do_maxcorrect (int argc, char **argv);
  39. static int do_mincorrect (int argc, char **argv);
  40. static int do_read (int argc, char **argv);
  41. static int do_set (int argc, char **argv);
  42.  
  43. /*************************************************************************** 
  44.      Static data.                                                             
  45.  ***************************************************************************/
  46.  
  47. static time_t correction     = 0;            /* difference in seconds         */
  48.                                             /* between remote and PC clock    */
  49. static int32 server          = 0L;            /* time server address            */
  50. static time_t max_correction = 0;            /* !0 is max correction allowed */
  51. static time_t min_correction = 0;            /* !0 is min correction allowed */
  52.  
  53. static BOOL set_clock        = FALSE;
  54.  
  55. static struct timer net_time_t;
  56. static struct socket time_socket;
  57.  
  58. static struct cmds time_cmds[] =
  59. { 
  60.     "maxcorrect",     do_maxcorrect, 0,    0,    NULLCHAR   , 
  61.     "mincorrect",    do_mincorrect, 0,    0,    NULLCHAR   , 
  62.     "read",            do_read,       0,    0,    NULLCHAR   , 
  63.     "server",        do_server,       0,    0,    NULLCHAR   , 
  64.     "set",            do_set,           0,    0,    NULLCHAR   , 
  65.     NULLCHAR   ,
  66. };
  67.  
  68. int dotime (int argc, char *argv[])
  69. {
  70.   return(subcmd(time_cmds, argc, argv));
  71. }
  72.  
  73. /* Display or set the timer server address. */
  74.  
  75. static int do_server(int argc, char *argv[])
  76. {
  77.   int32 n;                            /* temporary */
  78.  
  79.   if (argc < 2)
  80.   {
  81.     cwprintf(NULL, "%s\n", inet_ntoa(server));
  82.   }
  83.   else if (n = resolve(argv[1]), n == 0)
  84.   {
  85.     cwprintf(NULL, "Time - Bad host %s\n", argv[1]);
  86.     return (1);
  87.   }
  88.   else
  89.   {
  90.     server = n;
  91.   }
  92.   return (0);
  93. }
  94.  
  95. static void no_net_time(void *sk)
  96. {
  97.   cwprintf(NULL, "Time - No response from %s\n", inet_ntoa(server));
  98.   del_udp((struct socket *) sk);
  99.   set_clock = FALSE;
  100. }
  101.  
  102. time_t RiscTime(time_t *place)
  103. {
  104.   BOOL carry = FALSE;
  105.   char btime[] = "\x00\x00\x00\x00\x6A\x99\x6E\x33\x00";
  106.   char rtime[8], ntime[8], tzname[10];
  107.   int diff, loop, temp, tz;
  108.  
  109.   if (wimp_ver < 300)
  110.     return(time(place));
  111.     
  112.   os_swi2r(0x43048, NULL, NULL, (int *) tzname, &tz);
  113.   rtime[3] = 3;
  114.   os_word(14, &rtime[3]);
  115.   for (loop = 3; loop < 8; loop++)
  116.   {
  117.     temp = rtime[loop] - btime[loop] - carry;
  118.     ntime[loop] = temp & 0xFF;
  119.     carry = ((temp & 0x100) != 0);
  120.   }
  121.   diff = (*((int *) &ntime[4]));
  122.   temp = ((diff / 100) * 256) + (((diff % 100) * 256) + ntime[3]) / 100 + tz / 100;
  123.   if (place)
  124.     *place = temp;
  125.   return(temp);
  126. }
  127.  
  128. static void time_rec(struct socket *lsock, int16 rcvcnt)
  129. {
  130.   int loop;
  131.   struct socket fsocket;    /* socket address    */
  132.   struct mbuf *bp;
  133.   time_t pctime;            /* PC time            */
  134.   union
  135.   {
  136.     time_t time;
  137.     char bytes[sizeof (time_t)];
  138.   } result;                            /* data from remote    */
  139.  
  140.   if (recv_udp(lsock, &fsocket, &bp) != 4)
  141.   {
  142.     cwprintf(NULL, "TIME: receive failed\n");
  143.     stop_timer(&net_time_t);
  144.     del_udp(lsock);
  145.     done_set_time = FALSE;
  146.     return;
  147.   }
  148.   /* Calculate the correction value. */
  149.   loop = 0;
  150.   
  151.   while (pullone(&bp, &result.bytes[3 - loop]) == 1)
  152.     loop++;
  153.  
  154.   result.time -= 2208988800U;        /* adjust epoch    */
  155.  
  156.   pctime = RiscTime(NULL);
  157.   correction = result.time - pctime;
  158.   cwprintf(NULL, "TIME: correction = %ld seconds\n", correction);
  159.   cwprintf(NULL, "Net time   (GMT): %s", asctime (gmtime (&result.time)));
  160.   cwprintf(NULL, "Local time (GMT): %s", asctime (gmtime (&pctime)));
  161.   stop_timer(&net_time_t);
  162.   del_udp(lsock);
  163.  
  164.   if (set_clock)
  165.   {
  166.     char itime[8];
  167.     int correction_abs;
  168.  
  169.     correction_abs = (int) labs(correction);
  170.   
  171.     if (max_correction && correction_abs > max_correction)
  172.     {
  173.       cwprintf(NULL, "TIME: required correction (%ld) greater than maximum (%ld)\n",
  174.       correction, max_correction);
  175.       correction = 0;
  176.       return;
  177.     }
  178.   
  179.     if (min_correction && correction_abs < min_correction)
  180.     {
  181.       cwprintf(NULL, "TIME: required correction (%ld) less than minimum (%ld)\n",
  182.       correction, min_correction);
  183.       correction = 0;
  184.       return;
  185.     }
  186.     itime[0] = 3;
  187.     os_word(14, itime);
  188.     time_adj(itime, correction);
  189.     os_swi1(0x43047 /* Territory_SetTime */, (int) itime);
  190.     
  191.     correction = 0;                        /* no need for a correction now    */
  192.     cwprintf(NULL, "TIME: Arc clock reset\n");
  193.   }
  194.   set_clock = FALSE;
  195. }
  196.  
  197. /* Read the time from the remote and set the correction value. */
  198.  
  199. static int do_read(int argc, char *argv[])
  200. {
  201.   struct socket lsocket, fsocket;    /* socket address            */
  202.  
  203.   if (server == 0L)
  204.   {
  205.     cwprintf(NULL, "Time - Bad host %s\n", "0.0.0.0");
  206.     return (1);
  207.   }
  208.   if (run_timer(&net_time_t))
  209.   {
  210.     cwprintf(NULL, "Time - Already asking\n");
  211.     return (1);
  212.   }
  213.  
  214.   /* Set up the connection. */
  215.  
  216.   fsocket.address = server;
  217.   fsocket.port    = TIME_PORT;
  218.   lsocket.address = ip_addr;      /* our ip address */
  219.   lsocket.port    = lport++;      /* next unused port */
  220.  
  221.   open_udp(&lsocket, (void (*)())time_rec);
  222.   send_udp(&lsocket, &fsocket, 0, 0, 0, 0, 0, 0);
  223.   
  224.   time_socket     = lsocket;
  225.   net_time_t.func = no_net_time;  /* what to call on timeout */
  226.   net_time_t.arg  = (void *) &time_socket;
  227.   set_timer(&net_time_t, 30000);
  228.   start_timer(&net_time_t);
  229.   return(0);
  230. }
  231.  
  232.  
  233. /* Set the Arc's clock from the time server. */
  234.  
  235. static int do_set (int argc, char *argv[])
  236. {
  237.   if (do_read (0, NULL) != 0)
  238.     return (1);
  239.  
  240.   set_clock = TRUE;
  241.  
  242.   return (0);
  243. }
  244.  
  245.  
  246. static int do_maxcorrect(int argc, char *argv[])
  247. {
  248.   if(argc < 2)
  249.   {
  250.     cwprintf(NULL, "TIME: maximum correction: %d\n", max_correction);
  251.     return 0;
  252.   }
  253.   max_correction = atoi(argv[1]);
  254.   return 0;
  255. }
  256.  
  257. static int do_mincorrect(int argc, char *argv[])
  258. {
  259.   if(argc < 2)
  260.   {
  261.     cwprintf(NULL, "TIME: minimum correction: %d\n", min_correction);
  262.     return 0;
  263.   }
  264.   min_correction = atoi(argv[1]);
  265.   return 0;
  266. }
  267.